home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 4.iso / public / sox / raw.c < prev    next >
C/C++ Source or Header  |  1994-08-01  |  5KB  |  291 lines
  1. /*
  2.  * July 5, 1991
  3.  * Copyright 1991 Lance Norskog And Sundry Contributors
  4.  * This source code is freely redistributable and may be used for
  5.  * any purpose.  This copyright notice must be maintained. 
  6.  * Lance Norskog And Sundry Contributors are not responsible for 
  7.  * the consequences of using this software.
  8.  */
  9.  
  10. /*
  11.  * Sound Tools raw format file.
  12.  *
  13.  * Includes .ub, .uw, .sb, .sw, and .ul formats at end
  14.  */
  15.  
  16. /*
  17.  * Notes: most of the headerless formats set their handlers to raw
  18.  * in their startread/write routines.  
  19.  *
  20.  */
  21.  
  22. #include "st.h"
  23. #include "libst.h"
  24.  
  25. IMPORT int summary, verbose;
  26.  
  27. rawstartread(ft) 
  28. ft_t ft;
  29. {
  30. }
  31.  
  32. rawstartwrite(ft) 
  33. ft_t ft;
  34. {
  35. }
  36.  
  37. rawread(ft, buf, nsamp) 
  38. ft_t ft;
  39. long *buf, nsamp;
  40. {
  41.     register long datum;
  42.     int done = 0;
  43.  
  44.     switch(ft->info.size) {
  45.         case BYTE: switch(ft->info.style) {
  46.             case SIGN2:
  47.                 while(done < nsamp) {
  48.                     datum = getc(ft->fp);
  49.                     if (feof(ft->fp))
  50.                         return done;
  51.                     /* scale signed up to long's range */
  52.                     *buf++ = LEFT(datum, 24);
  53.                     done++;
  54.                 }
  55.                 return done;
  56.             case UNSIGNED:
  57.                 while(done < nsamp) {
  58.                     datum = getc(ft->fp);
  59.                     if (feof(ft->fp))
  60.                         return done;
  61.                     /* Convert to signed */
  62.                     datum ^= 128;
  63.                     /* scale signed up to long's range */
  64.                     *buf++ = LEFT(datum, 24);
  65.                     done++;
  66.                 }
  67.                 return done;
  68.             case ULAW:
  69.                 /* grab table from Posk stuff */
  70.                 while(done < nsamp) {
  71.                     datum = getc(ft->fp);
  72.                     if (feof(ft->fp))
  73.                         return done;
  74.                     datum = st_ulaw_to_linear(datum);
  75.                     /* scale signed up to long's range */
  76.                     *buf++ = LEFT(datum, 16);
  77.                     done++;
  78.                 }
  79.                 return done;
  80.             case ALAW:
  81.                 fail("No A-Law support");
  82.                 return done;
  83.             }
  84.         case WORD: switch(ft->info.style) {
  85.             case SIGN2:
  86.                 while(done < nsamp) {
  87.                     datum = rshort(ft);
  88.                     if (feof(ft->fp))
  89.                         return done;
  90.                     /* scale signed up to long's range */
  91.                     *buf++ = LEFT(datum, 16);
  92.                     done++;
  93.                 }
  94.                 return done;
  95.             case UNSIGNED:
  96.                 while(done < nsamp) {
  97.                     datum = rshort(ft);
  98.                     if (feof(ft->fp))
  99.                         return done;
  100.                     /* Convert to signed */
  101.                     datum ^= 0x8000;
  102.                     /* scale signed up to long's range */
  103.                     *buf++ = LEFT(datum, 16);
  104.                     done++;
  105.                 }
  106.                 return done;
  107.             case ULAW:
  108.                 fail("No U-Law support for shorts");
  109.                 return done;
  110.             case ALAW:
  111.                 fail("No A-Law support");
  112.                 return done;
  113.             }
  114.         }
  115.     fail("Drop through in rawread!");
  116. }
  117.  
  118. void
  119. rawwrite(ft, buf, nsamp) 
  120. ft_t ft;
  121. long *buf, nsamp;
  122. {
  123.     register int datum;
  124.     int done = 0;
  125.  
  126.     switch(ft->info.size) {
  127.         case BYTE: switch(ft->info.style) {
  128.             case SIGN2:
  129.                 while(done < nsamp) {
  130.                     /* scale signed up to long's range */
  131.                     datum = RIGHT(*buf++, 24);
  132.                     putc(datum, ft->fp);
  133.                     done++;
  134.                 }
  135.                 return;
  136.             case UNSIGNED:
  137.                 while(done < nsamp) {
  138.                     /* scale signed up to long's range */
  139.                     datum = RIGHT(*buf++, 24);
  140.                     /* Convert to unsigned */
  141.                     datum ^= 128;
  142.                     putc(datum, ft->fp);
  143.                     done++;
  144.                 }
  145.                 return;
  146.             case ULAW:
  147.                 /* grab table from Posk stuff */
  148.                 while(done < nsamp) {
  149.                     /* scale signed up to long's range */
  150.                     datum = RIGHT(*buf++, 16);
  151.                     datum = st_linear_to_ulaw(datum);
  152.                     putc(datum, ft->fp);
  153.                     done++;
  154.                 }
  155.                 return;
  156.             case ALAW:
  157.                 fail("No A-Law support");
  158.                 return;
  159.             }
  160.         case WORD: switch(ft->info.style) {
  161.             case SIGN2:
  162.                 while(done < nsamp) {
  163.                     /* scale signed up to long's range */
  164.                     datum = RIGHT(*buf++, 16);
  165.                     wshort(ft, datum);
  166.                     done++;
  167.                 }
  168.                 return;
  169.             case UNSIGNED:
  170.                 while(done < nsamp) {
  171.                     /* scale signed up to long's range */
  172.                     datum = RIGHT(*buf++, 16);
  173.                     /* Convert to unsigned */
  174.                     datum ^= 0x8000;
  175.                     wshort(ft, datum);
  176.                     done++;
  177.                 }
  178.                 return;
  179.             case ULAW:
  180.                 fail("No U-Law support for shorts");
  181.                 return;
  182.             case ALAW:
  183.                 fail("No A-Law support");
  184.                 return;
  185.             }
  186.         }
  187.     /* My, there's a lot of code missing! */
  188.     fail("Drop through in rawwrite!");
  189. }
  190.  
  191.  
  192. /*
  193.  * Set parameters to the fixed parameters known for this format,
  194.  * and change format to raw format.
  195.  */
  196.  
  197. static  rawdefaults();
  198.  
  199. /* Signed byte */
  200. sbstartread(ft) 
  201. ft_t ft;
  202. {
  203.     ft->info.size = BYTE;
  204.     ft->info.style = SIGN2;
  205.     rawdefaults(ft);
  206. }
  207.  
  208. sbstartwrite(ft) 
  209. ft_t ft;
  210. {
  211.     ft->info.size = BYTE;
  212.     ft->info.style = SIGN2;
  213.     rawdefaults(ft);
  214. }
  215.  
  216. ubstartread(ft) 
  217. ft_t ft;
  218. {
  219.     ft->info.size = BYTE;
  220.     ft->info.style = UNSIGNED;
  221.     rawdefaults(ft);
  222. }
  223.  
  224. ubstartwrite(ft) 
  225. ft_t ft;
  226. {
  227.     ft->info.size = BYTE;
  228.     ft->info.style = UNSIGNED;
  229.     rawdefaults(ft);
  230. }
  231.  
  232. uwstartread(ft) 
  233. ft_t ft;
  234. {
  235.     ft->info.size = WORD;
  236.     ft->info.style = UNSIGNED;
  237.     rawdefaults(ft);
  238. }
  239.  
  240. uwstartwrite(ft) 
  241. ft_t ft;
  242. {
  243.     ft->info.size = WORD;
  244.     ft->info.style = UNSIGNED;
  245.     rawdefaults(ft);
  246. }
  247.  
  248. swstartread(ft) 
  249. ft_t ft;
  250. {
  251.     ft->info.size = WORD;
  252.     ft->info.style = SIGN2;
  253.     rawdefaults(ft);
  254. }
  255.  
  256. swstartwrite(ft) 
  257. ft_t ft;
  258. {
  259.     ft->info.size = WORD;
  260.     ft->info.style = SIGN2;
  261.     rawdefaults(ft);
  262. }
  263.  
  264. ulstartread(ft) 
  265. ft_t ft;
  266. {
  267.     ft->info.size = BYTE;
  268.     ft->info.style = ULAW;
  269.     rawdefaults(ft);
  270. }
  271.  
  272. ulstartwrite(ft) 
  273. ft_t ft;
  274. {
  275.     ft->info.size = BYTE;
  276.     ft->info.style = ULAW;
  277.     rawdefaults(ft);
  278. }
  279.  
  280. static
  281. rawdefaults(ft)
  282. ft_t ft;
  283. {
  284.     if (ft->info.rate == 0)
  285.         ft->info.rate = 8000;
  286.     if (ft->info.channels == -1)
  287.         ft->info.channels = 1;
  288. }
  289.  
  290.  
  291.